EgaLabs / node-ejsception

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                     = path.dirname(__dirname);

const Throwable                = require(path.join(root, "Throwable.js"));

const Exception                = require(path.join(root, "Exception.js"));

const RuntimeException         = require(path.join(root, "RuntimeException.js"));

const IllegalArgumentException = require(path.join(root, "IllegalArgumentException.js"));

const InvalidPathException     = require(path.join(root, "InvalidPathException.js"));

// :: TESTING

// test the InvalidPathException 'class'

describe("InvalidPathException", () => {

    // :: INHERITED PROTOTYPE

	it("should inherit from 'Throwable'", () => {

		expect(new InvalidPathException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new InvalidPathException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new InvalidPathException()).toEqual(jasmine.any(RuntimeException));

    });

    it("should inherit from 'IllegalArgumentException'", () => {

        expect(new InvalidPathException()).toEqual(jasmine.any(IllegalArgumentException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(InvalidPathException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(InvalidPathException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(InvalidPathException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(InvalidPathException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(InvalidPathException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(InvalidPathException.prototype.name).toEqual("InvalidPathException");

    });

    it("should have a dummy default value as message", () => {

        expect(InvalidPathException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(InvalidPathException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new InvalidPathException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                arg2 = (j % 2 === 0 ? undefined : null);

                expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test).not.toThrowError("parameter 'code' must be a 'number'");

            }

        }

        test = (() => new InvalidPathException());

        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

    });

    it("should instantiate with parameters", () => {

        let arg1, arg2, test1, test2;

        const args1 = [undefined, null, InvalidPathException.prototype.message];

        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        test1       = (() => new InvalidPathException(arg1));

        test2       = (() => new InvalidPathException(arg1, arg2));

        for (let i = 0; i < args1.length; i += 1) {

            arg1 = args1[i];

            for (let j = 0; j < args2.length; j += 1) {

                arg2 = args2[j];

                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

        }

    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        let arg1, arg2, test21, test22, test11;

        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

        const noNmb = [{}, true, false, '', "qwerty", () => null];

        test22      = (() => new InvalidPathException(arg1, arg2));

        test21      = (() => new InvalidPathException(null, arg2));

        test11      = (() => new InvalidPathException(arg1));

        if (typeof Symbol === "function") {

            noStr.push(Symbol("symbol"));

            noNmb.push(Symbol("symbol"));

        }

        for (let i = 0; i < noStr.length; i += 1) {

            arg1 = noStr[i];

            for (let j = 0; j < noNmb.length; j += 1) {

                arg2 = noNmb[j];

                expect(test22).toThrowError("parameter 'message' must be a 'string'");

                expect(test21).toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test11).toThrowError("parameter 'message' must be a 'string'");

        }

    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new InvalidPathException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new InvalidPathException(arg1, arg2);

                if (i % 2 === 0) {

                    expect(source1.message).toEqual(message);

                    expect(source2.message).toEqual(message);

                } else {

                    expect(source1.message).toEqual(InvalidPathException.prototype.message);

                    expect(source2.message).toEqual(InvalidPathException.prototype.message);

                }

                if (j % 2 === 0) {

                    expect(source2.code).toEqual(code);

                } else {

                    expect(source2.code).toBeNull();

                }

                expect(source1.code).toBeNull();

            }

        }

    });

    // :: MEMBER METHODS

    const message = "asdf";

    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new InvalidPathException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new InvalidPathException(arg1, arg2);

                const str1    = source1.toString();

                const str2    = source2.toString();

                let exp1, exp2;

                exp1 = exp2 = "InvalidPathException";

                if (j % 2 === 0) {

                    exp2 += " (0x" + code.toString(16) + ')';

                }

                if (i % 2 === 0) {

                    exp1 += ": " + message + '.';

                    exp2 += ": " + message + '.';

                } else {

                    exp1 += ": " + InvalidPathException.prototype.message + '.';

                    exp2 += ": " + InvalidPathException.prototype.message + '.';

                }

                expect(str1).toEqual(exp1);

                expect(str2).toEqual(exp2);

            }

        }

    });

    it("#native()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new InvalidPathException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new InvalidPathException(arg1, arg2);

                const err1    = source1.native();

                const err2    = source2.native();

                const exp1    = (i % 2 === 0 ? message : InvalidPathException.prototype.message);

                const exp2    = exp1;

                expect(err1).toEqual(new Error(exp1));

                expect(err2).toEqual(new Error(exp2));

            }

        }

    });